const napcatAPI = require('../api/napcat-api');
const logger = require('../utils/logger');

class MessageSender {
    constructor(config) {
        this.config = config;
        this.selfId = null;
    }

    async initialize() {
        logger.info('🔄 初始化消息发送器...');
        await this.getSelfId();
    }

    async getSelfId() {
        try {
            const result = await napcatAPI.getLoginInfo();
            if (napcatAPI.isSuccess(result)) {
                this.selfId = napcatAPI.getData(result).user_id;
                logger.info(`🤖 机器人QQ号: ${this.selfId}`);
            }
        } catch (error) {
            logger.error('❌ 获取机器人QQ号失败:', error);
        }
    }

    // ==================== 消息发送 API ====================

    /**
     * 发送私聊消息
     * @param {number} user_id - 用户QQ号
     * @param {string} message - 消息内容
     * @param {boolean} auto_escape - 是否转义CQ码
     * @returns {Promise<Object>} 发送结果
     */
    async sendPrivateMessage(user_id, message, auto_escape = false) {
        try {
            const result = await napcatAPI.sendPrivateMessage(user_id, message, auto_escape);
            if (napcatAPI.isSuccess(result)) {
                logger.info(`📤 发送私聊消息 | 👤 ${user_id} | ${this.formatMessage(message)}`);
                return {
                    success: true,
                    message_id: napcatAPI.getMessageId(result),
                    data: napcatAPI.getData(result)
                };
            }
            return { success: false, error: 'API响应失败' };
        } catch (error) {
            logger.error(`💥 发送私聊消息异常 | 👤 ${user_id}:`, error);
            return { success: false, error: error.message };
        }
    }

    /**
     * 发送群聊消息
     * @param {number} group_id - 群号
     * @param {string} message - 消息内容
     * @param {boolean} auto_escape - 是否转义CQ码
     * @returns {Promise<Object>} 发送结果
     */
    async sendGroupMessage(group_id, message, auto_escape = false) {
        try {
            const result = await napcatAPI.sendGroupMessage(group_id, message, auto_escape);
            if (napcatAPI.isSuccess(result)) {
                logger.info(`📤 发送群聊消息 | 👥 ${group_id} | ${this.formatMessage(message)}`);
                return {
                    success: true,
                    message_id: napcatAPI.getMessageId(result),
                    data: napcatAPI.getData(result)
                };
            }
            return { success: false, error: 'API响应失败' };
        } catch (error) {
            logger.error(`💥 发送群聊消息异常 | 👥 ${group_id}:`, error);
            return { success: false, error: error.message };
        }
    }

    /**
     * 发送消息（通用）
     * @param {string} message_type - 消息类型 private/group
     * @param {number} target_id - 目标ID
     * @param {string} message - 消息内容
     * @param {boolean} auto_escape - 是否转义CQ码
     * @returns {Promise<Object>} 发送结果
     */
    async sendMessage(message_type, target_id, message, auto_escape = false) {
        try {
            const result = await napcatAPI.sendMessage(message_type, target_id, message, auto_escape);
            if (napcatAPI.isSuccess(result)) {
                const targetType = message_type === 'private' ? '私聊' : '群聊';
                logger.info(`📤 发送${targetType}消息 | ${targetType === '私聊' ? '👤' : '👥'} ${target_id} | ${this.formatMessage(message)}`);
                return {
                    success: true,
                    message_id: napcatAPI.getMessageId(result),
                    data: napcatAPI.getData(result)
                };
            }
            return { success: false, error: 'API响应失败' };
        } catch (error) {
            logger.error(`💥 发送消息异常:`, error);
            return { success: false, error: error.message };
        }
    }

    /**
     * 撤回消息
     * @param {number} message_id - 消息ID
     * @returns {Promise<Object>} 撤回结果
     */
    async recallMessage(message_id) {
        try {
            const result = await napcatAPI.deleteMessage(message_id);
            if (napcatAPI.isSuccess(result)) {
                logger.info(`🗑️ 撤回消息 | 📝 ${message_id}`);
                return { success: true };
            }
            return { success: false, error: '撤回失败' };
        } catch (error) {
            logger.error(`💥 撤回消息异常 | 📝 ${message_id}:`, error);
            return { success: false, error: error.message };
        }
    }

    /**
     * 获取消息详情
     * @param {number} message_id - 消息ID
     * @returns {Promise<Object>} 消息详情
     */
    async getMessage(message_id) {
        try {
            const result = await napcatAPI.getMessage(message_id);
            if (napcatAPI.isSuccess(result)) {
                return { success: true, data: napcatAPI.getData(result) };
            }
            return { success: false, error: '获取消息失败' };
        } catch (error) {
            logger.error(`💥 获取消息异常 | 📝 ${message_id}:`, error);
            return { success: false, error: error.message };
        }
    }

    /**
     * 获取合并转发消息
     * @param {number} message_id - 消息ID
     * @returns {Promise<Object>} 转发消息详情
     */
    async getForwardMessage(message_id) {
        try {
            const result = await napcatAPI.getForwardMessage(message_id);
            if (napcatAPI.isSuccess(result)) {
                return { success: true, data: napcatAPI.getData(result) };
            }
            return { success: false, error: '获取转发消息失败' };
        } catch (error) {
            logger.error(`💥 获取转发消息异常 | 📝 ${message_id}:`, error);
            return { success: false, error: error.message };
        }
    }

    /**
     * 发送好友赞
     * @param {number} user_id - 用户QQ号
     * @param {number} times - 赞的次数
     * @returns {Promise<Object>} 发送结果
     */
    async sendLike(user_id, times = 1) {
        try {
            const result = await napcatAPI.sendLike(user_id, times);
            if (napcatAPI.isSuccess(result)) {
                logger.info(`👍 发送好友赞 | 👤 ${user_id} | ${times}次`);
                return { success: true };
            }
            return { success: false, error: '发送赞失败' };
        } catch (error) {
            logger.error(`💥 发送赞异常 | 👤 ${user_id}:`, error);
            return { success: false, error: error.message };
        }
    }

    // ==================== 群组操作 API ====================

    /**
     * 群组踢人
     * @param {number} group_id - 群号
     * @param {number} user_id - 用户QQ号
     * @param {boolean} reject_add_request - 是否拒绝再次加群
     * @returns {Promise<Object>} 操作结果
     */
    async setGroupKick(group_id, user_id, reject_add_request = false) {
        try {
            const result = await napcatAPI.setGroupKick(group_id, user_id, reject_add_request);
            if (napcatAPI.isSuccess(result)) {
                logger.info(`👋 踢出群成员 | 👥 ${group_id} | 👤 ${user_id}`);
                return { success: true };
            }
            return { success: false, error: '踢人失败' };
        } catch (error) {
            logger.error(`💥 踢人异常 | 👥 ${group_id} 👤 ${user_id}:`, error);
            return { success: false, error: error.message };
        }
    }

    /**
     * 群组单人禁言
     * @param {number} group_id - 群号
     * @param {number} user_id - 用户QQ号
     * @param {number} duration - 禁言时长（秒）
     * @returns {Promise<Object>} 操作结果
     */
    async setGroupBan(group_id, user_id, duration = 30 * 60) {
        try {
            const result = await napcatAPI.setGroupBan(group_id, user_id, duration);
            if (napcatAPI.isSuccess(result)) {
                const timeStr = duration === 0 ? '解除禁言' : `禁言 ${duration}秒`;
                logger.info(`🔇 ${timeStr} | 👥 ${group_id} | 👤 ${user_id}`);
                return { success: true };
            }
            return { success: false, error: '禁言失败' };
        } catch (error) {
            logger.error(`💥 禁言异常 | 👥 ${group_id} 👤 ${user_id}:`, error);
            return { success: false, error: error.message };
        }
    }

    /**
     * 群组全员禁言
     * @param {number} group_id - 群号
     * @param {boolean} enable - 是否开启全员禁言
     * @returns {Promise<Object>} 操作结果
     */
    async setGroupWholeBan(group_id, enable = true) {
        try {
            const result = await napcatAPI.setGroupWholeBan(group_id, enable);
            if (napcatAPI.isSuccess(result)) {
                logger.info(`🔇 ${enable ? '开启' : '关闭'}全员禁言 | 👥 ${group_id}`);
                return { success: true };
            }
            return { success: false, error: '全员禁言操作失败' };
        } catch (error) {
            logger.error(`💥 全员禁言异常 | 👥 ${group_id}:`, error);
            return { success: false, error: error.message };
        }
    }

    /**
     * 设置群管理员
     * @param {number} group_id - 群号
     * @param {number} user_id - 用户QQ号
     * @param {boolean} enable - 是否设置为管理员
     * @returns {Promise<Object>} 操作结果
     */
    async setGroupAdmin(group_id, user_id, enable = true) {
        try {
            const result = await napcatAPI.setGroupAdmin(group_id, user_id, enable);
            if (napcatAPI.isSuccess(result)) {
                logger.info(`👑 ${enable ? '设置' : '取消'}管理员 | 👥 ${group_id} | 👤 ${user_id}`);
                return { success: true };
            }
            return { success: false, error: '设置管理员失败' };
        } catch (error) {
            logger.error(`💥 设置管理员异常 | 👥 ${group_id} 👤 ${user_id}:`, error);
            return { success: false, error: error.message };
        }
    }

    /**
     * 设置群名片
     * @param {number} group_id - 群号
     * @param {number} user_id - 用户QQ号
     * @param {string} card - 群名片内容
     * @returns {Promise<Object>} 操作结果
     */
    async setGroupCard(group_id, user_id, card = '') {
        try {
            const result = await napcatAPI.setGroupCard(group_id, user_id, card);
            if (napcatAPI.isSuccess(result)) {
                logger.info(`📇 设置群名片 | 👥 ${group_id} | 👤 ${user_id} | ${card}`);
                return { success: true };
            }
            return { success: false, error: '设置群名片失败' };
        } catch (error) {
            logger.error(`💥 设置群名片异常 | 👥 ${group_id} 👤 ${user_id}:`, error);
            return { success: false, error: error.message };
        }
    }

    /**
     * 设置群名
     * @param {number} group_id - 群号
     * @param {string} group_name - 新群名
     * @returns {Promise<Object>} 操作结果
     */
    async setGroupName(group_id, group_name) {
        try {
            const result = await napcatAPI.setGroupName(group_id, group_name);
            if (napcatAPI.isSuccess(result)) {
                logger.info(`🏷️ 修改群名 | 👥 ${group_id} | ${group_name}`);
                return { success: true };
            }
            return { success: false, error: '修改群名失败' };
        } catch (error) {
            logger.error(`💥 修改群名异常 | 👥 ${group_id}:`, error);
            return { success: false, error: error.message };
        }
    }

    /**
     * 退出群组
     * @param {number} group_id - 群号
     * @param {boolean} is_dismiss - 是否解散群
     * @returns {Promise<Object>} 操作结果
     */
    async setGroupLeave(group_id, is_dismiss = false) {
        try {
            const result = await napcatAPI.setGroupLeave(group_id, is_dismiss);
            if (napcatAPI.isSuccess(result)) {
                logger.info(`👋 ${is_dismiss ? '解散' : '退出'}群组 | 👥 ${group_id}`);
                return { success: true };
            }
            return { success: false, error: '退出群组失败' };
        } catch (error) {
            logger.error(`💥 退出群组异常 | 👥 ${group_id}:`, error);
            return { success: false, error: error.message };
        }
    }

    /**
     * 设置群组专属头衔
     * @param {number} group_id - 群号
     * @param {number} user_id - 用户QQ号
     * @param {string} special_title - 专属头衔
     * @param {number} duration - 持续时间（秒）
     * @returns {Promise<Object>} 操作结果
     */
    async setGroupSpecialTitle(group_id, user_id, special_title = '', duration = -1) {
        try {
            const result = await napcatAPI.setGroupSpecialTitle(group_id, user_id, special_title, duration);
            if (napcatAPI.isSuccess(result)) {
                logger.info(`👑 设置专属头衔 | 👥 ${group_id} | 👤 ${user_id} | ${special_title}`);
                return { success: true };
            }
            return { success: false, error: '设置头衔失败' };
        } catch (error) {
            logger.error(`💥 设置头衔异常 | 👥 ${group_id} 👤 ${user_id}:`, error);
            return { success: false, error: error.message };
        }
    }

    // ==================== 文件操作 API ====================

    /**
     * 上传群文件
     * @param {number} group_id - 群号
     * @param {string} file - 文件路径/URL
     * @param {string} name - 文件名
     * @param {string} folder - 文件夹ID
     * @returns {Promise<Object>} 上传结果
     */
    async uploadGroupFile(group_id, file, name, folder = '') {
        try {
            const result = await napcatAPI.uploadGroupFile(group_id, file, name, folder);
            if (napcatAPI.isSuccess(result)) {
                logger.info(`📎 上传群文件 | 👥 ${group_id} | ${name}`);
                return { success: true };
            }
            return { success: false, error: '上传文件失败' };
        } catch (error) {
            logger.error(`💥 上传文件异常 | 👥 ${group_id}:`, error);
            return { success: false, error: error.message };
        }
    }

    /**
     * 获取群文件系统信息
     * @param {number} group_id - 群号
     * @returns {Promise<Object>} 文件系统信息
     */
    async getGroupFileSystemInfo(group_id) {
        try {
            const result = await napcatAPI.getGroupFileSystemInfo(group_id);
            if (napcatAPI.isSuccess(result)) {
                return { success: true, data: napcatAPI.getData(result) };
            }
            return { success: false, error: '获取文件系统信息失败' };
        } catch (error) {
            logger.error(`💥 获取文件系统信息异常 | 👥 ${group_id}:`, error);
            return { success: false, error: error.message };
        }
    }

    // ==================== 资源获取 API ====================

    /**
     * 获取登录号信息
     * @returns {Promise<Object>} 登录信息
     */
    async getLoginInfo() {
        try {
            const result = await napcatAPI.getLoginInfo();
            if (napcatAPI.isSuccess(result)) {
                return { success: true, data: napcatAPI.getData(result) };
            }
            return { success: false, error: '获取登录信息失败' };
        } catch (error) {
            logger.error('💥 获取登录信息异常:', error);
            return { success: false, error: error.message };
        }
    }

    /**
     * 获取好友列表
     * @returns {Promise<Object>} 好友列表
     */
    async getFriendList() {
        try {
            const result = await napcatAPI.getFriendList();
            if (napcatAPI.isSuccess(result)) {
                return { success: true, data: napcatAPI.getData(result) };
            }
            return { success: false, error: '获取好友列表失败' };
        } catch (error) {
            logger.error('💥 获取好友列表异常:', error);
            return { success: false, error: error.message };
        }
    }

    /**
     * 获取群列表
     * @returns {Promise<Object>} 群列表
     */
    async getGroupList() {
        try {
            const result = await napcatAPI.getGroupList();
            if (napcatAPI.isSuccess(result)) {
                return { success: true, data: napcatAPI.getData(result) };
            }
            return { success: false, error: '获取群列表失败' };
        } catch (error) {
            logger.error('💥 获取群列表异常:', error);
            return { success: false, error: error.message };
        }
    }

    /**
     * 获取群信息
     * @param {number} group_id - 群号
     * @param {boolean} no_cache - 是否不使用缓存
     * @returns {Promise<Object>} 群信息
     */
    async getGroupInfo(group_id, no_cache = false) {
        try {
            const result = await napcatAPI.getGroupInfo(group_id, no_cache);
            if (napcatAPI.isSuccess(result)) {
                return { success: true, data: napcatAPI.getData(result) };
            }
            return { success: false, error: '获取群信息失败' };
        } catch (error) {
            logger.error(`💥 获取群信息异常 | 👥 ${group_id}:`, error);
            return { success: false, error: error.message };
        }
    }

    /**
     * 获取群成员列表
     * @param {number} group_id - 群号
     * @param {boolean} no_cache - 是否不使用缓存
     * @returns {Promise<Object>} 群成员列表
     */
    async getGroupMemberList(group_id, no_cache = false) {
        try {
            const result = await napcatAPI.getGroupMemberList(group_id, no_cache);
            if (napcatAPI.isSuccess(result)) {
                return { success: true, data: napcatAPI.getData(result) };
            }
            return { success: false, error: '获取群成员列表失败' };
        } catch (error) {
            logger.error(`💥 获取群成员列表异常 | 👥 ${group_id}:`, error);
            return { success: false, error: error.message };
        }
    }

    /**
     * 获取群成员信息
     * @param {number} group_id - 群号
     * @param {number} user_id - 用户QQ号
     * @param {boolean} no_cache - 是否不使用缓存
     * @returns {Promise<Object>} 群成员信息
     */
    async getGroupMemberInfo(group_id, user_id, no_cache = false) {
        try {
            const result = await napcatAPI.getGroupMemberInfo(group_id, user_id, no_cache);
            if (napcatAPI.isSuccess(result)) {
                return { success: true, data: napcatAPI.getData(result) };
            }
            return { success: false, error: '获取群成员信息失败' };
        } catch (error) {
            logger.error(`💥 获取群成员信息异常 | 👥 ${group_id} 👤 ${user_id}:`, error);
            return { success: false, error: error.message };
        }
    }

    /**
     * 获取群荣誉信息
     * @param {number} group_id - 群号
     * @param {string} type - 荣誉类型
     * @returns {Promise<Object>} 荣誉信息
     */
    async getGroupHonorInfo(group_id, type = 'all') {
        try {
            const result = await napcatAPI.getGroupHonorInfo(group_id, type);
            if (napcatAPI.isSuccess(result)) {
                return { success: true, data: napcatAPI.getData(result) };
            }
            return { success: false, error: '获取群荣誉信息失败' };
        } catch (error) {
            logger.error(`💥 获取群荣誉信息异常 | 👥 ${group_id}:`, error);
            return { success: false, error: error.message };
        }
    }

    /**
     * 获取图片信息
     * @param {string} file - 图片文件名/URL
     * @returns {Promise<Object>} 图片信息
     */
    async getImage(file) {
        try {
            const result = await napcatAPI.getImage(file);
            if (napcatAPI.isSuccess(result)) {
                return { success: true, data: napcatAPI.getData(result) };
            }
            return { success: false, error: '获取图片信息失败' };
        } catch (error) {
            logger.error('💥 获取图片信息异常:', error);
            return { success: false, error: error.message };
        }
    }

    /**
     * 图片OCR
     * @param {string} image - 图片ID/URL
     * @returns {Promise<Object>} OCR结果
     */
    async ocrImage(image) {
        try {
            const result = await napcatAPI.ocrImage(image);
            if (napcatAPI.isSuccess(result)) {
                return { success: true, data: napcatAPI.getData(result) };
            }
            return { success: false, error: 'OCR识别失败' };
        } catch (error) {
            logger.error('💥 OCR识别异常:', error);
            return { success: false, error: error.message };
        }
    }

    /**
     * 获取运行状态
     * @returns {Promise<Object>} 运行状态
     */
    async getStatus() {
        try {
            const result = await napcatAPI.getStatus();
            if (napcatAPI.isSuccess(result)) {
                return { success: true, data: napcatAPI.getData(result) };
            }
            return { success: false, error: '获取运行状态失败' };
        } catch (error) {
            logger.error('💥 获取运行状态异常:', error);
            return { success: false, error: error.message };
        }
    }

    /**
     * 获取版本信息
     * @returns {Promise<Object>} 版本信息
     */
    async getVersionInfo() {
        try {
            const result = await napcatAPI.getVersionInfo();
            if (napcatAPI.isSuccess(result)) {
                return { success: true, data: napcatAPI.getData(result) };
            }
            return { success: false, error: '获取版本信息失败' };
        } catch (error) {
            logger.error('💥 获取版本信息异常:', error);
            return { success: false, error: error.message };
        }
    }

    // ==================== 请求处理 API ====================

    /**
     * 处理加好友请求
     * @param {string} flag - 请求标识
     * @param {boolean} approve - 是否同意
     * @param {string} remark - 好友备注
     * @returns {Promise<Object>} 处理结果
     */
    async setFriendAddRequest(flag, approve = true, remark = '') {
        try {
            const result = await napcatAPI.setFriendAddRequest(flag, approve, remark);
            if (napcatAPI.isSuccess(result)) {
                logger.info(`👥 处理好友请求 | ${approve ? '同意' : '拒绝'} | ${remark}`);
                return { success: true };
            }
            return { success: false, error: '处理好友请求失败' };
        } catch (error) {
            logger.error('💥 处理好友请求异常:', error);
            return { success: false, error: error.message };
        }
    }

    /**
     * 处理加群请求
     * @param {string} flag - 请求标识
     * @param {string} sub_type - 请求类型 add/invite
     * @param {boolean} approve - 是否同意
     * @param {string} reason - 拒绝理由
     * @returns {Promise<Object>} 处理结果
     */
    async setGroupAddRequest(flag, sub_type, approve = true, reason = '') {
        try {
            const result = await napcatAPI.setGroupAddRequest(flag, sub_type, approve, reason);
            if (napcatAPI.isSuccess(result)) {
                const action = sub_type === 'add' ? '加群' : '邀请';
                logger.info(`👥 处理${action}请求 | ${approve ? '同意' : '拒绝'} | ${reason}`);
                return { success: true };
            }
            return { success: false, error: '处理群请求失败' };
        } catch (error) {
            logger.error('💥 处理群请求异常:', error);
            return { success: false, error: error.message };
        }
    }

    // ==================== 工具方法 ====================

    /**
     * 格式化消息内容用于日志
     * @param {string} message - 消息内容
     * @returns {string} 格式化后的消息
     */
    formatMessage(message) {
        if (typeof message !== 'string') return '[复杂消息]';
        
        // 简化CQ码显示
        let simplified = message
            .replace(/\[CQ:image[^\]]+\]/g, '[图片]')
            .replace(/\[CQ:face[^\]]+\]/g, '[表情]')
            .replace(/\[CQ:record[^\]]+\]/g, '[语音]')
            .replace(/\[CQ:video[^\]]+\]/g, '[视频]')
            .replace(/\[CQ:at,qq=(\d+)\]/g, (match, qq) => qq === 'all' ? '@全体成员' : `@${qq}`)
            .replace(/\[CQ:share[^\]]+\]/g, '[分享链接]');
        
        return simplified.length > 50 ? simplified.substring(0, 50) + '...' : simplified;
    }

    /**
     * 获取机器人QQ号
     * @returns {string} 机器人QQ号
     */
    getSelfId() {
        return this.selfId;
    }
}

module.exports = MessageSender;